home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / network / lattice / dulib.lzh / DU_LIB / EVENTS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-10  |  4.8 KB  |  307 lines
  1. /*
  2.   DU_LIB v2
  3.   Gem Window Management & Dialog Library For Lattice C
  4.   ©1994, by Craig Graham.
  5.   
  6.   Based on the DU_LIBv1 Library for HiSoft Basic.
  7. */
  8.  
  9. /*
  10.   Event & object handling
  11. */
  12.  
  13. #include "dulib.h"
  14.  
  15. #define KEY_CODES                    -1
  16. #define DIALOG_LAYER_KEY_HANDLER    -2
  17.  
  18. event Get_object_event(short dialog, short ob)
  19. {
  20.     Elist *e;
  21.  
  22.     e=NULL;
  23.  
  24.     if (find_event(dialog,ob,&e))
  25.     {
  26.         return e->this_event;
  27.     }else{
  28.         return 0;
  29.     }
  30. }
  31.  
  32. short Set_object_event(short dialog, short ob, event e)
  33. {
  34.     Elist *n;
  35.     n=NULL;
  36.  
  37.     if (!find_event(dialog,ob,&n))
  38.         n=new_event_struct(dialog,ob);
  39.  
  40.     n->this_event=e;
  41.  
  42.     return 0;
  43. }
  44.  
  45. event Get_object_devent(short dialog, short ob)
  46. {
  47.     Elist *e;
  48.  
  49.     e=NULL;
  50.  
  51.     if (find_event(dialog,ob,&e))
  52.     {
  53.         return e->this_devent;
  54.     }else{
  55.         return 0;
  56.     }
  57. }
  58.  
  59. short Set_object_devent(short dialog, short ob, event e)
  60. {
  61.     Elist *n;
  62.     n=NULL;
  63.  
  64.     if (!find_event(dialog,ob,&n))
  65.         n=new_event_struct(dialog,ob);
  66.  
  67.     n->this_devent=e;
  68.  
  69.     return 0;
  70. }
  71.  
  72. CallBack Get_object_callback(short dialog, short ob)
  73. {
  74.     Elist *e;
  75.     e=NULL;
  76.  
  77.     if (find_event(dialog,ob,&e))
  78.     {
  79.         return e->callback;
  80.     }else{
  81.         return 0;
  82.     }
  83. }
  84.  
  85. short Set_object_callback(short dialog, short ob, CallBack c)
  86. {
  87.     Elist *n;
  88.     n=NULL;
  89.     
  90.     if (!find_event(dialog,ob,&n))
  91.         n=new_event_struct(dialog,ob);
  92.  
  93.     n->callback=c;
  94.     
  95.     return 0;
  96. }
  97.  
  98. CallBack Get_object_dcallback(short dialog, short ob)
  99. {
  100.     Elist *e;
  101.     e=NULL;
  102.  
  103.     if (find_event(dialog,ob,&e))
  104.     {
  105.         return e->dcallback;
  106.     }else{
  107.         return 0;
  108.     }
  109. }
  110.  
  111. short Set_object_dcallback(short dialog, short ob, CallBack c)
  112. {
  113.     Elist *n;
  114.     n=NULL;
  115.     
  116.     if (!find_event(dialog,ob,&n))
  117.         n=new_event_struct(dialog,ob);
  118.  
  119.     n->dcallback=c;
  120.     
  121.     return 0;
  122. }
  123.  
  124. /*
  125.     Keyboard Processing Callbacks
  126. */
  127.  
  128. /* Specific Object Keyboard callbacks (Object Layer) */
  129. CallBack Get_object_Kcallback(short dialog, short ob)
  130. {
  131.     Elist *e;
  132.     e=NULL;
  133.  
  134.     if (find_event(dialog,ob,&e))
  135.     {
  136.         return e->Kcallback;
  137.     }else{
  138.         return 0;
  139.     }
  140. }
  141.  
  142. short Set_object_Kcallback(short dialog, short ob, CallBack c)
  143. {
  144.     Elist *n;
  145.     n=NULL;
  146.  
  147.     if (!find_event(dialog,ob,&n))
  148.         n=new_event_struct(dialog,ob);
  149.  
  150.     n->Kcallback=c;
  151.     
  152.     return 0;
  153. }
  154.  
  155. /* Dialog related Callbacks (Dialog Layer) */
  156. CallBack Get_dialog_Kcallback(short dialog)
  157. {
  158.     Elist *e;
  159.     e=NULL;
  160.  
  161.     if (find_event(dialog,DIALOG_LAYER_KEY_HANDLER,&e))
  162.     {
  163.         return e->Kcallback;
  164.     }else{
  165.         return 0;
  166.     }
  167. }
  168.  
  169. short Set_dialog_Kcallback(short dialog, CallBack c)
  170. {
  171.     Elist *n;
  172.     n=NULL;
  173.     
  174.     if (!find_event(dialog, DIALOG_LAYER_KEY_HANDLER, &n))
  175.         n=new_event_struct(dialog, DIALOG_LAYER_KEY_HANDLER);
  176.  
  177.     n->Kcallback=c;
  178.     
  179.     return 0;
  180. }
  181.  
  182. /* Key specific keyboard callbacks. (Application Global Layer) */
  183. CallBack Get_key_callback(short key)
  184. {
  185.     Elist *e;
  186.     e=NULL;
  187.  
  188.     if (find_event(KEY_CODES,key,&e))
  189.     {
  190.         return e->Kcallback;
  191.     }else{
  192.         return 0;
  193.     }
  194. }
  195.  
  196. short Set_key_callback(short key, CallBack c)
  197. {
  198.     Elist *n;
  199.     n=NULL;
  200.     
  201.     if (!find_event(KEY_CODES,key,&n))
  202.         n=new_event_struct(KEY_CODES,key);
  203.  
  204.     n->Kcallback=c;
  205.     
  206.     return 0;
  207. }
  208.  
  209. /*
  210.     REDRAW FUNCTIONS
  211. */
  212. CallBack Get_object_redraw(short dialog, short ob)
  213. {
  214.     Elist *e;
  215.     e=NULL;
  216.  
  217.     if (find_event(dialog,ob,&e))
  218.     {
  219.         return e->redraw;
  220.     }else{
  221.         return 0;
  222.     }
  223. }
  224.  
  225. short Set_object_redraw(short dialog, short ob, CallBack c)
  226. {
  227.     Elist *n;
  228.     n=NULL;
  229.     
  230.     if (!find_event(dialog,ob,&n))
  231.         n=new_event_struct(dialog,ob);
  232.  
  233.     n->redraw=c;
  234.     
  235.     return 0;
  236. }
  237.  
  238. /*
  239.     Support function for searching & inserting in the event/callback tables
  240. */
  241. short find_event(short dialog, short ob, Elist *ee[])
  242. {
  243.     short o;
  244.     Elist *e;
  245.     
  246.     o=ob-1;
  247.     if (dialog!=KEY_CODES)
  248.         e=event_value[dialog];
  249.     else
  250.         e=key_values;
  251.  
  252.     if (e!=NULL)
  253.     {
  254.         for(o=e->object; (e!=NULL)&&(o!=ob); )
  255.         {
  256.             o=e->object;
  257.             if (o!=ob) { e=e->next; }
  258.         }
  259.     }
  260.     
  261.     ee[0]=e;
  262.     
  263.     if (o!=ob)
  264.     {
  265.         return 0;
  266.     } else {
  267.         return 1;
  268.     }
  269. }
  270.  
  271. /*
  272.     Create a new event structure for an object & initialise it to all disabled
  273. */
  274. Elist* new_event_struct(short dialog, short ob)
  275. {
  276.     Elist *n;
  277.     
  278.     n=(Elist*)malloc(sizeof(Elist));
  279.  
  280.     if (dialog!=KEY_CODES)
  281.     {
  282.         n->object=ob;
  283.         n->next=event_value[dialog];
  284.         event_value[dialog]=n;
  285.     }else{
  286.         n->object=ob;                    // for key codes, AES key code is passed in ob.
  287.         n->next=key_values;
  288.         key_values=n;
  289.     }
  290.  
  291. /* Initially, nothing actually in the event structure */
  292.     n->this_event=0;            // Single click event
  293.     n->this_devent=0;            // Double click event
  294.     n->callback=NULL;            // Single click callback
  295.     n->dcallback=NULL;            // Double click callback
  296.     n->redraw=NULL;                // Redraw callback function 
  297.     n->Kcallback=NULL;            // Keyboard callback
  298.     n->stext.texts=NULL;        // Scroll text
  299.     n->wtext.text=NULL;            // Text widget
  300.     n->wtext.current_line=NULL;
  301.     n->wtext.display_baseline=NULL;
  302.     n->popup_form=0;            // Icon popup
  303.     n->popup_icon_current=0;    // Icon popup current icon
  304.     
  305.     return n;
  306. }
  307.